import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:permission_handler/permission_handler.dart';
import '../../../common/api/activity_api.dart';
import '../../../common/models/index.dart';
import '../../../common/routers/names.dart';
import '../../../common/services/amap_location_service.dart';
import '../../../common/services/user_service.dart';
import '../../../common/services/business_orchestration_service.dart';
import '../../../common/services/message_storage_service.dart';
import '../../../common/utils/loading_util.dart';

class HomeIndexController extends GetxController {
  static const String tag = 'HomeIndexController';
  
  // 🔥 注入服务
  final AmapLocationService _amapLocationService = Get.find<AmapLocationService>();
  
  HomeIndexController();

  PageController? _pageController;
  
  // PageController的getter
  PageController get pageController {
    _pageController ??= PageController();
    return _pageController!;
  }
  
  // 当前页面索引
  RxInt currentPageIndex = 0.obs;
  
  // 🖼️ 当前活动的图片索引和总数
  RxInt currentImageIndex = 0.obs;
  RxInt currentImageCount = 0.obs;
  
  // 🎯 活动列表数据
  RxList<ActivityEntity> activities = <ActivityEntity>[].obs;
  
  // 🔄 加载状态
  RxBool isLoading = false.obs;
  RxBool hasMore = true.obs;
  RxInt currentPage = 1.obs;
  RxBool isRefreshing = false.obs;  // 🔥 下拉刷新状态
  RxDouble pullDistance = 0.0.obs;  // 🔥 下拉距离
  RxBool hasShownNoMoreToast = false.obs;  // 🔥 是否已显示"没有更多"提示
  
  // 📍 位置信息（直接从 AmapLocationService 获取）
  // 不再在 Controller 中维护位置信息，全部从 AmapLocationService 获取
  
  // 🔔 未读消息数量（预留）
  RxInt unreadCount = 0.obs;

  _initData() async {
    debugPrint('🚀 =============== 首页初始化开始 ===============');
    
    // 🔥 先加载活动列表（使用默认位置），让用户快速看到内容
    await loadActivityList();
    
    // 🔥 后台获取位置，定位成功后重新计算距离
    _getLocationInBackground();
    
    // 🔥 手动打印第一个活动的信息（因为 onPageChanged 首次不会触发）
    if (activities.isNotEmpty) {
      _printActivityInfo(0);
      // 注意：图片信息已在 loadActivityList() 中初始化，无需重复
    }
    
    update(["home_index"]);
    debugPrint('✅ =============== 首页初始化完成 ===============');
  }
  
  /// 📍 后台获取位置信息并更新活动距离
  Future<void> _getLocationInBackground() async {
    try {
      debugPrint('📍 =============== 开始后台获取位置 ===============');
      
      final oldLat = _amapLocationService.latitude;
      final oldLng = _amapLocationService.longitude;
      
      // 🔥 智能判断是否显示权限说明：
      // - 如果是首次请求权限（denied状态），显示权限说明
      // - 如果已授权或已拒绝，静默检查
      final currentStatus = await Permission.location.status;
      final showRationale = currentStatus == PermissionStatus.denied;
      
      debugPrint('📍 当前权限状态: $currentStatus');
      debugPrint('📍 是否显示权限说明: $showRationale');
      
      final success = await _amapLocationService.smartLocation(
        showRationale: showRationale,  // 🔥 首次请求显示说明，后续静默
      );
      
      if (success) {
        debugPrint('✅ 定位成功');
        debugPrint('📍 新位置: ${_amapLocationService.locationText}');
        debugPrint('📍 坐标: ${_amapLocationService.latitude}, ${_amapLocationService.longitude}');
        
        // 🔥 检查位置是否变化
        final locationChanged = (oldLat - _amapLocationService.latitude).abs() > 0.001 || 
                               (oldLng - _amapLocationService.longitude).abs() > 0.001;
        
        if (locationChanged && activities.isNotEmpty) {
          debugPrint('📍 位置发生变化，重新计算活动距离');
          await _recalculateDistances();
        }
      } else {
        debugPrint('⚠️ 定位失败或权限被拒绝');
        debugPrint('📍 使用默认位置: ${_amapLocationService.locationText}');
      }
      
    } catch (e) {
      debugPrint('💥 后台获取位置异常: $e');
    } finally {
      debugPrint('🏁 =============== 位置获取结束 ===============');
    }
  }
  
  /// 📏 重新计算活动距离（定位成功后调用）
  Future<void> _recalculateDistances() async {
    try {
      debugPrint('📏 =============== 重新计算活动距离 ===============');
      debugPrint('📍 当前位置: ${_amapLocationService.latitude}, ${_amapLocationService.longitude}');
      
      // 🔥 调用API重新获取带距离的活动列表
      final response = await ActivityApi.getNearbyActivities(
        latitude: _amapLocationService.latitude,
        longitude: _amapLocationService.longitude,
        radius: 50.0,
        limit: activities.length, // 获取当前列表数量
        page: 1,
        sortBy: 'distance_time',
        order: 'asc',
      );
      
      debugPrint('✅ 距离重新计算完成');
      debugPrint('📊 更新活动数量: ${response.activities.length}');
      
      // 🔥 创建活动ID到新活动的映射
      final updatedActivitiesMap = <int, ActivityEntity>{};
      for (var activity in response.activities) {
        updatedActivitiesMap[activity.activityId] = activity;
      }
      
      // 🔥 用更新后的活动替换原有活动（保持列表位置不变）
      for (int i = 0; i < activities.length; i++) {
        final activityId = activities[i].activityId;
        if (updatedActivitiesMap.containsKey(activityId)) {
          // 直接用新的活动对象替换（新对象包含更新后的距离）
          activities[i] = updatedActivitiesMap[activityId]!;
        }
      }
      
      // 🔥 重新排序（优先距离，其次时间）
      _sortActivities();
      
      // 更新UI
      update(["home_index"]);
      
      debugPrint('✅ 活动距离已更新并重新排序');
      
    } catch (e) {
      debugPrint('❌ 重新计算距离失败: $e');
      // 静默失败，不影响用户体验
    }
  }
  
  /// 🎯 加载活动列表
  Future<void> loadActivityList({bool refresh = false}) async {
    if (isLoading.value) {
      debugPrint('⚠️ 正在加载中，忽略重复请求');
      return;
    }
    
    try {
      debugPrint('🔄 =============== 开始加载活动列表 ===============');
      
      // 如果是刷新，重置页码和状态
      if (refresh) {
        currentPage.value = 1;
        activities.clear();
        hasShownNoMoreToast.value = false;  // 🔥 重置提示标志
      }
      
      isLoading.value = true;
      
      debugPrint('📊 请求参数:');
      debugPrint('   纬度: ${_amapLocationService.latitude}');
      debugPrint('   经度: ${_amapLocationService.longitude}');
      debugPrint('   半径: 50公里');
      debugPrint('   页码: ${currentPage.value}');
      debugPrint('   每页数量: 20');
      
      // 🔥 调用真实API
      final response = await ActivityApi.getNearbyActivities(
        latitude: _amapLocationService.latitude,
        longitude: _amapLocationService.longitude,
        radius: 50.0,
        limit: 20,  
        page: currentPage.value,
        sortBy: 'distance_time',
        order: 'asc',
      );
      
      debugPrint('✅ 活动列表加载成功');
      debugPrint('📊 新增活动数量: ${response.activities.length}');
      
      // 保存新获取的活动列表，用于预加载
      final newActivities = response.activities;
      
      // 添加到列表
      if (refresh) {
        activities.value = response.activities;
      } else {
        activities.addAll(response.activities);
      }
      
      // 判断是否还有更多数据
      // 🔥 如果返回的数据数量等于请求的limit，说明可能还有更多数据
      // 如果小于limit，说明已经到底了
      final requestedLimit = 20;
      final newHasMore = response.activities.length >= requestedLimit;
      
      // 🔥 如果从"没有更多"变成"有更多"，重置提示标志
      if (!hasMore.value && newHasMore) {
        hasShownNoMoreToast.value = false;
      }
      
      hasMore.value = newHasMore;
      
      debugPrint('📱 当前活动总数: ${activities.length}');
      debugPrint('📄 是否还有更多: ${hasMore.value}');
      
      // 🔥 如果没有更多数据，给用户提示
      if (!hasMore.value && activities.isNotEmpty && !refresh) {
        debugPrint('📄 已加载全部活动');
      }
      
      // 🔥 前端排序：优先距离，其次时间
      _sortActivities();
      
      // 🖼️ 初始化图片索引和总数（如果是刷新或首次加载）
      if (activities.isNotEmpty && (refresh || currentPage.value == 1)) {
        final images = activities[0].activityImages ?? [];
        currentImageCount.value = images.length;
        currentImageIndex.value = 0;
      }
      
      // 🖼️ 立即预加载所有新获取活动的图片
      _precacheNewActivitiesImages(newActivities);
      
      update(["home_index"]);
      
    } catch (e) {
      debugPrint('❌ 加载活动列表失败: $e');
      
      Get.snackbar(
        '加载失败',
        e.toString(),
        snackPosition: SnackPosition.TOP,
        duration: const Duration(seconds: 3),
      );
    } finally {
      isLoading.value = false;
    }
  }
  
  /// 🔄 活动列表排序（优先距离，其次时间）
  void _sortActivities() {
    activities.sort((a, b) {
      // 1️⃣ 首先按距离排序（距离相差超过1公里，优先距离）
      if (a.distance != null && b.distance != null) {
        final distanceDiff = a.distance! - b.distance!;
        if (distanceDiff.abs() > 1) {
          return distanceDiff > 0 ? 1 : -1;
        }
      }
      
      // 2️⃣ 距离相近时，按时间排序（新的排前面）
      if (a.activityPublishTime != null && b.activityPublishTime != null) {
        try {
          final timeA = DateTime.parse(a.activityPublishTime!);
          final timeB = DateTime.parse(b.activityPublishTime!);
          return timeB.compareTo(timeA); // 降序（新的排前面）
        } catch (e) {
          return 0;
        }
      }
      
      return 0;
    });
    
    debugPrint('✅ 前端排序完成（优先距离，其次时间）');
    
    // 打印前5个活动
    if (activities.isNotEmpty) {
      debugPrint('📊 排序后前5个活动:');
      for (var i = 0; i < activities.length && i < 5; i++) {
        final activity = activities[i];
        debugPrint('   ${i + 1}. ${activity.activityTitle} - ${activity.distanceText}');
      }
    }
  }
  
  /// 📄 加载更多活动（静默加载，不显示Toast）
  Future<void> loadMoreActivities() async {
    if (isLoading.value) {
      return;
    }
    
    // 🔥 如果没有更多数据了，静默返回（不显示Toast）
    if (!hasMore.value) {
      debugPrint('📄 没有更多数据，跳过加载');
      return;
    }
    
    debugPrint('📄 加载更多活动，当前页码: ${currentPage.value}');
    currentPage.value++;
    await loadActivityList();
  }

  /// 📋 打印活动信息（提取为独立方法，方便复用）
  void _printActivityInfo(int index) {
    if (index < 0 || index >= activities.length) {
      return;
    }
    
    final activity = activities[index];
    debugPrint('');
    debugPrint('🎯 =============== 当前活动信息 ===============');
    debugPrint('📍 索引: ${index + 1}/${activities.length}');
    debugPrint('🏷️ 活动ID: ${activity.activityId}');
    debugPrint('📝 活动标题: ${activity.activityTitle}');
    debugPrint('📅 发布时间: ${activity.activityPublishTime}');
    debugPrint('👤 发布者: ${activity.publisherNickname} (ID: ${activity.publisherId})');
    
    // 🔥 智能显示手机号（如果活动数据中没有，尝试从好友列表获取）
    String? phoneToDisplay = activity.publisherPhone;
    String phoneSource = '活动数据';
    
    if ((phoneToDisplay == null || phoneToDisplay.isEmpty) && activity.publisherId != null) {
      phoneToDisplay = UserService.to.getFriendPhone(activity.publisherId!);
      if (phoneToDisplay != null && phoneToDisplay.isNotEmpty) {
        phoneSource = '好友列表';
      }
    }
    
    debugPrint('📱 发布者手机: ${phoneToDisplay ?? "未知"} ${phoneToDisplay != null && phoneToDisplay.isNotEmpty ? "($phoneSource)" : ""}');
    debugPrint('⚧️ 发布者性别: ${activity.publisherGender ?? "未知"}');
    debugPrint('📍 距离: ${activity.distanceText}');
    debugPrint('🖼️ 图片数量: ${activity.activityImages?.length ?? 0}');
    
    if (activity.activityDetails != null && activity.activityDetails!.isNotEmpty) {
      final details = activity.activityDetails!;
      final shortDetails = details.length > 50 ? '${details.substring(0, 50)}...' : details;
      debugPrint('📄 活动详情: $shortDetails');
    }
    
    // 🔥 判断关系类型（明确传入当前索引）
    final relationType = getPublisherRelationType(activityIndex: index);
    final relationText = relationType == 'mine' ? '我的活动' 
                       : relationType == 'friend' ? '好友活动' 
                       : '陌生人活动';
    debugPrint('🤝 关系类型: $relationText');
    
    debugPrint('🎯 =============================================');
    debugPrint('');
  }
  
  /// 🔄 页面切换回调
  void onPageChanged(int index) {
    currentPageIndex.value = index;
    
    // 🔥 打印当前活动的详细信息
    _printActivityInfo(index);
    
    // 🔥 更新当前活动的图片总数
    if (index < activities.length) {
      final images = activities[index].activityImages ?? [];
      currentImageCount.value = images.length;
      currentImageIndex.value = 0; // 重置图片索引
    }
    
    // 🔥 触发图片预加载（预加载下一个和下下个活动的图片）
    _precacheNextImages(index);
    
    // 🔥 在倒数第2个数据时就开始加载新数据
    // 🔥 关键：只有当 hasMore.value 为 true 时才触发，避免重复检查
    final shouldLoadMore = index >= activities.length - 2;
    
    if (shouldLoadMore && !isLoading.value && hasMore.value) {
      debugPrint('📄 到达倒数第2个，自动加载更多数据');
      debugPrint('   当前索引: $index, 总数: ${activities.length}');
      loadMoreActivities();
    }
    
    // 🔥 如果是最后一个活动且没有更多数据，显示"已经到底了"的提示（只显示一次）
    final isLastItem = index == activities.length - 1;
    if (isLastItem && !hasMore.value && activities.isNotEmpty && !hasShownNoMoreToast.value) {
      debugPrint('📄 已到达最后一个活动，显示"已经到底了"提示');
      LoadingUtil.toast('已经到底了，没有更多活动');
      hasShownNoMoreToast.value = true;  // 标记已显示
    }
  }
  
  /// 🖼️ 更新当前活动的图片索引
  void updateImageIndex(int index) {
    currentImageIndex.value = index;
  }
  
  /// 🖼️ 预加载下一个和下下个活动的图片
  void _precacheNextImages(int currentIndex) {
    try {
      // 🔥 添加延迟，避免在滑动时立即触发大量预加载
      Future.delayed(const Duration(milliseconds: 500), () {
        // 预加载下一个活动的图片
        if (currentIndex + 1 < activities.length) {
          final nextActivity = activities[currentIndex + 1];
          _precacheActivityImages(nextActivity);
        }
        
        // 预加载下下个活动的图片
        if (currentIndex + 2 < activities.length) {
          final nextNextActivity = activities[currentIndex + 2];
          _precacheActivityImages(nextNextActivity);
        }
      });
    } catch (e) {
      // 静默处理异常
    }
  }
  
  /// 🖼️ 预加载单个活动的所有图片
  void _precacheActivityImages(ActivityEntity activity) {
    try {
      final images = activity.activityImages ?? [];
      if (images.isEmpty) return;
      
      final context = Get.context;
      if (context == null) {
        return; // 静默返回
      }
      
      // 预加载活动的所有图片（最多预加载3张，避免内存占用过大）
      final imagesToPrecache = images.take(3);
      
      for (final imageUrl in imagesToPrecache) {
        if (imageUrl.isNotEmpty) {
          try {
            precacheImage(
              NetworkImage(imageUrl),
              context,
              size: const Size(720, 1280), // 🔥 降低预加载尺寸，提升速度（原1080x1920）
            ).catchError((e) {
              // 静默处理预加载失败（不打印日志）
            });
          } catch (e) {
            // 静默处理异常
          }
        }
      }
      
      debugPrint('🖼️ 触发预加载: ${activity.activityTitle} (${imagesToPrecache.length}张)');
    } catch (e) {
      // 静默处理异常
    }
  }
  
  /// 🖼️ 预加载新获取的所有活动的图片
  void _precacheNewActivitiesImages(List<ActivityEntity> newActivities) {
    if (newActivities.isEmpty) {
      debugPrint('📭 没有新活动需要预加载图片');
      return;
    }
    
    try {
      final context = Get.context;
      if (context == null) {
        debugPrint('⚠️ Context为空，无法预加载图片');
        return;
      }
      
      debugPrint('🖼️ =============== 开始预加载新活动图片 ===============');
      debugPrint('📊 新活动数量: ${newActivities.length}');
      
      // 🔥 增加延迟到1秒，确保平台通道和缓存管理器完全初始化
      Future.delayed(const Duration(seconds: 1), () {
        int totalImageCount = 0;
        
        // 遍历所有新活动，预加载它们的图片
        for (final activity in newActivities) {
          final images = activity.activityImages ?? [];
          
          if (images.isEmpty) {
            debugPrint('📭 活动无图片: ${activity.activityTitle}');
            continue;
          }
          
          // 预加载活动的所有图片（最多预加载3张，避免内存占用过大）
          final imagesToPrecache = images.take(3);
          
          for (final imageUrl in imagesToPrecache) {
            if (imageUrl.isNotEmpty) {
              try {
                precacheImage(
                  NetworkImage(imageUrl),
                  context,
                  size: const Size(720, 1280), // 🔥 降低预加载尺寸，提升速度（原1080x1920）
                ).then((_) {
                  // 预加载成功（静默）
                }).catchError((e) {
                  // 静默处理预加载失败（不打印日志，避免污染控制台）
                });
                
                totalImageCount++;
              } catch (e) {
                // 静默处理异常
              }
            }
          }
          
          debugPrint('🖼️ 触发预加载: ${activity.activityTitle} (${imagesToPrecache.length}张图片)');
        }
        
        debugPrint('✅ 图片预加载已触发');
        debugPrint('📊 总计: ${newActivities.length}个活动，$totalImageCount张图片');
        debugPrint('🖼️ ===============================================');
      });
      
    } catch (e) {
      debugPrint('❌ 批量预加载图片失败: $e');
    }
  }

  /// 🔄 刷新活动列表
  /// 
  /// [skipLocationUpdate] 是否跳过位置更新（当用户手动选择位置时应该跳过）
  Future<void> refreshActivities({bool skipLocationUpdate = false}) async {
    debugPrint('🔄 刷新活动列表 (skipLocationUpdate: $skipLocationUpdate)');
    await loadActivityList(refresh: true);
    
    // 🔥 刷新后打印第一个活动的信息
    if (activities.isNotEmpty) {
      _printActivityInfo(0);
    }
    
    // 🔥 只有在不跳过位置更新时才重新定位
    if (!skipLocationUpdate) {
      debugPrint('🔄 刷新后重新获取位置并更新距离');
      _getLocationInBackground();
    } else {
      debugPrint('⏭️ 跳过位置更新（用户已手动选择位置）');
    }
  }
  
  /// 🔄 更新下拉距离
  void updatePullDistance(double delta) {
    if (currentPageIndex.value == 0 && !isRefreshing.value) {
      pullDistance.value += delta;
      // 🔥 只在达到阈值时输出日志，减少性能开销
      if (pullDistance.value >= 80 && pullDistance.value - delta < 80) {
        debugPrint('✅ 下拉距离达到刷新阈值: ${pullDistance.value.toStringAsFixed(1)}px');
      }
    }
  }
  
  /// 🔄 检查是否触发刷新
  void checkRefreshTrigger() {
    debugPrint('🔍 检查刷新触发 - 下拉距离: ${pullDistance.value.toStringAsFixed(1)}px');
    
    if (pullDistance.value >= 80 && !isRefreshing.value) {
      debugPrint('✅ 达到刷新阈值，触发刷新');
      triggerRefresh();
    } else {
      debugPrint('⚠️ 未达到刷新阈值（需要80px）');
    }
    
    // 重置下拉距离
    pullDistance.value = 0;
  }
  
  /// 🔄 触发下拉刷新
  Future<void> triggerRefresh() async {
    if (isRefreshing.value || isLoading.value) {
      debugPrint('⚠️ 正在刷新或加载中，忽略重复请求');
      pullDistance.value = 0;
      return;
    }
    
    debugPrint('🔄 =============== 触发下拉刷新 ===============');
    
    try {
      isRefreshing.value = true;
      pullDistance.value = 0;  // 重置下拉距离
      
      // 重置页码和数据
      currentPage.value = 1;
      activities.clear();
      hasMore.value = true;
      
      // 加载最新数据
      await loadActivityList(refresh: true);
      
      // 🔥 刷新后打印第一个活动的信息
      if (activities.isNotEmpty) {
        _printActivityInfo(0);
      }
      
      // 刷新成功提示
      Get.snackbar(
        '',
        '刷新成功',
        snackPosition: SnackPosition.TOP,
        backgroundColor: Colors.black.withOpacity(0.7),
        colorText: Colors.white,
        duration: const Duration(seconds: 1),
        margin: const EdgeInsets.only(top: 100, left: 100, right: 100),
        borderRadius: 12,
        padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
        messageText: const Text(
          '刷新成功',
          style: TextStyle(
            color: Colors.white,
            fontSize: 13,
          ),
          textAlign: TextAlign.center,
        ),
        titleText: const SizedBox.shrink(),
      );
      
      debugPrint('✅ 下拉刷新完成');
      
    } catch (e) {
      debugPrint('❌ 下拉刷新失败: $e');
      
      Get.snackbar(
        '',
        '刷新失败，请重试',
        snackPosition: SnackPosition.TOP,
        backgroundColor: Colors.red.withOpacity(0.7),
        colorText: Colors.white,
        duration: const Duration(seconds: 2),
        margin: const EdgeInsets.only(top: 100, left: 100, right: 100),
        borderRadius: 12,
        padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
        messageText: const Text(
          '刷新失败，请重试',
          style: TextStyle(
            color: Colors.white,
            fontSize: 13,
          ),
          textAlign: TextAlign.center,
        ),
        titleText: const SizedBox.shrink(),
      );
      
    } finally {
      isRefreshing.value = false;
      pullDistance.value = 0;
    }
  }

  /// 📱 消息按钮点击事件
  void onMessageTap() {
    debugPrint('$tag: 用户点击消息图标');
    
    // 跳转到消息页面
    Get.toNamed(RouteNames.messageMessageIndex);
    debugPrint('$tag: 跳转到消息页面');
  }

  /// 📍 位置按钮点击事件 - 跳转到地图页面选择位置
  void onLocationTap() async {
    debugPrint('📍 =============== 用户点击位置按钮 ===============');
    debugPrint('📍 当前位置: ${_amapLocationService.locationText}');
    debugPrint('📍 定位成功: ${_amapLocationService.isSuccess}');
    debugPrint('📍 坐标: ${_amapLocationService.latitude}, ${_amapLocationService.longitude}');
    
    // 🔥 跳转到地图页面（不传参，让地图页面自动定位）
    debugPrint('🗺️ 跳转到地图页面');
    
    final result = await Get.toNamed(RouteNames.systemAmap);
    
    debugPrint('🔙 从地图页面返回，结果: $result');
    
    // 如果用户选择了新位置，更新位置并刷新活动列表
    if (result != null && result is Map<String, dynamic>) {
      final address = result['address'] as String?;
      final latitude = result['latitude'] as double?;
      final longitude = result['longitude'] as double?;
      
      if (address != null && latitude != null && longitude != null) {
        debugPrint('📍 用户选择了新位置:');
        debugPrint('   地址: $address');
        debugPrint('   坐标: $latitude, $longitude');
        
        // 🎯 更新AmapLocationService的位置信息
        await _amapLocationService.updateLocationManually(
          address: address,
          latitude: latitude,
          longitude: longitude,
        );
        
        // 🔄 刷新活动列表（使用新位置重新计算距离）
        // 🔥 关键：跳过自动定位，直接使用用户选择的位置
        debugPrint('🔄 位置已更新，开始刷新活动列表（使用用户选择的位置）...');
        await refreshActivities(skipLocationUpdate: true);
        
        debugPrint('✅ 位置更新和活动刷新完成');
      } else {
        debugPrint('⚠️ 返回数据不完整');
      }
    } else {
      debugPrint('ℹ️ 用户未选择新位置');
    }
    
    debugPrint('🏁 =============== 位置按钮处理完成 ===============');
  }
  
  /// ✕ 关闭当前活动（切换到下一个）
  void onCloseActivity() {
    final nextIndex = currentPageIndex.value + 1;
    
    if (nextIndex < activities.length) {
      // 切换到下一个活动
      pageController.animateToPage(
        nextIndex,
        duration: const Duration(milliseconds: 300),
        curve: Curves.easeInOut,
      );
    } else {
      // 🔥 已经是最后一个了，会自动触发加载更多，直接切换即可
      debugPrint('🔄 已是最后一个，即将加载更多活动');
    }
  }
  
  /// 🔍 获取指定活动发布者的关系类型
  /// 
  /// @param activityIndex 活动索引，如果为null则使用当前页面索引
  /// 
  /// 返回值：
  /// - 'mine': 我自己发布的活动
  /// - 'friend': 我的好友发布的活动
  /// - 'stranger': 陌生人发布的活动
  String getPublisherRelationType({int? activityIndex}) {
    // 🔥 使用传入的索引，如果没有传入则使用当前页面索引
    final index = activityIndex ?? currentPageIndex.value;
    
    if (activities.isEmpty || index >= activities.length || index < 0) {
      return 'stranger';
    }
    
    final activity = activities[index];
    final publisherId = activity.publisherId;
    
    if (publisherId == null) {
      return 'stranger';
    }
    
    // 检查是否是自己
    final currentUserId = UserService.to.currentUserProfile?.userid;
    if (currentUserId != null && publisherId == currentUserId) {
      return 'mine';
    }
    
    // 检查是否是好友
    final isFriend = UserService.to.isFriend(publisherId);
    if (isFriend) {
      return 'friend';
    }
    
    return 'stranger';
  }
  
  /// 💬 联系我按钮点击（好友才会显示此按钮）
  void onContactTap() {
    if (activities.isEmpty || currentPageIndex.value >= activities.length) {
      return;
    }
    
    final activity = activities[currentPageIndex.value];
    final publisherId = activity.publisherId;
    
    if (publisherId == null) {
      LoadingUtil.toast('无法获取发布者信息');
      return;
    }
    
    // 🔥 智能获取手机号：先从活动数据获取，如果为空则从好友列表获取
    String? publisherPhone = activity.publisherPhone;
    
    if (publisherPhone == null || publisherPhone.isEmpty) {
      debugPrint('⚠️ 活动数据中手机号为空，尝试从好友列表获取');
      debugPrint('   发布者ID: $publisherId');
      
      // 🔥 从好友列表中获取手机号
      publisherPhone = UserService.to.getFriendPhone(publisherId);
      
      if (publisherPhone == null || publisherPhone.isEmpty) {
        LoadingUtil.toast('无法获取好友手机号，请稍后重试');
        debugPrint('❌ 从好友列表也无法获取手机号，publisherId=$publisherId');
        return;
      }
      
      debugPrint('✅ 从好友列表成功获取手机号');
    }
    
    debugPrint('💬 点击联系我，跳转到聊天页面');
    debugPrint('   好友ID: $publisherId');
    debugPrint('   好友手机: $publisherPhone');
    debugPrint('   好友名称: ${activity.publisherNickname}');
    
    // 🔥 跳转到聊天页面（传递手机号）
    Get.toNamed(
      RouteNames.messageMessageChat,
      arguments: {
        'friendId': publisherId,           // 数据库ID（用于UI）
        'friendPhone': publisherPhone,     // 🔥 手机号（用于融云）
        'friendName': activity.publisherNickname ?? '未知用户',
        'friendAvatar': activity.publisherAvatar ?? '',
      },
    );
  }
  
  /// 👥 加好友按钮点击（陌生人才会显示此按钮）
  Future<void> onAddFriendTap() async {
    if (activities.isEmpty || currentPageIndex.value >= activities.length) {
      return;
    }
    
    final activity = activities[currentPageIndex.value];
    final publisherId = activity.publisherId;
    
    if (publisherId == null) {
      LoadingUtil.toast('无法获取发布者信息');
      return;
    }
    
    try {
      debugPrint('👥 =============== 开始加好友（使用BusinessOrchestrationService） ===============');
      debugPrint('   接收者ID: $publisherId');
      debugPrint('   接收者名称: ${activity.publisherNickname}');
      
      LoadingUtil.show('发送好友申请中...');
      
      // 🔥 使用BusinessOrchestrationService统一入口（API + IM通知）
      final result = await BusinessOrchestrationService.to.sendFriendRequest(
        receiverId: publisherId,
        message: '你好，我想加你为好友',
        checkPermission: true,
      );
      
      LoadingUtil.dismiss();
      
      if (result['status'] == 'success') {
        debugPrint('✅ 好友申请发送成功（已自动发送IM通知）');
        // 🔥 不需要刷新好友申请列表，因为我发送的申请不在"收到的申请列表"中
      } else if (result['status'] == 'warning') {
        // 🔥 警告状态：重复发送、已是好友、被拒绝等
        debugPrint('⚠️ ${result['message']}');
        LoadingUtil.toast(result['message'] ?? '操作提示');
      } else {
        LoadingUtil.error(result['message'] ?? '发送好友申请失败');
        debugPrint('❌ 好友申请发送失败: ${result['message']}');
      }
      
    } catch (e) {
      LoadingUtil.dismiss();
      debugPrint('❌ 加好友异常: $e');
      
      // 处理常见错误
      String errorMessage = '发送好友申请失败';
      if (e.toString().contains('积分不足')) {
        errorMessage = '积分不足，无法发送好友申请';
      } else if (e.toString().contains('已经是好友')) {
        errorMessage = '你们已经是好友了';
      } else if (e.toString().contains('已发送过申请')) {
        errorMessage = '已经发送过好友申请，请耐心等待';
      }
      
      LoadingUtil.error(errorMessage);
    }
  }
  
  /// ❤️ 加入活动按钮点击 - 跳转到活动详情页面
  void onJoinActivity() {
    if (activities.isEmpty || currentPageIndex.value >= activities.length) {
      return;
    }
    
    final activity = activities[currentPageIndex.value];
    
    debugPrint('🎯 加入活动: ${activity.activityTitle} (ID: ${activity.activityId})');
    
    // 🔥 跳转到活动详情页面（传递活动ID和完整活动数据）
    Get.toNamed(
      '/activity_activity_detial',  // RouteNames.activityActivityDetial
      arguments: {
        'activityId': activity.activityId,
        'activity': activity.toJson(),  // 传递完整活动数据
        'fromPage': 'home_index',
      },
    );
  }

  @override
  void onInit() {
    super.onInit();
    _initData();
    _initUnreadMessageListener();
  }

  @override
  void onReady() {
    super.onReady();
  }

  @override
  void onClose() {
    _pageController?.dispose();
    super.onClose();
  }
  
  /// 🔔 初始化未读消息监听
  void _initUnreadMessageListener() {
    try {
      debugPrint('🔔 初始化未读消息监听');
      
      // 🔥 监听 MessageStorageService 的全局未读数变化
      ever(MessageStorageService.to.totalUnreadCount, (count) {
        // 计算总未读数（聊天 + 好友申请 + 活动申请）
        final total = count.chatUnreadCount + 
                     count.friendRequestUnreadCount + 
                     count.activityRequestUnreadCount;
        
        debugPrint('🔔 未读消息数量更新: $total');
        debugPrint('   聊天: ${count.chatUnreadCount}');
        debugPrint('   好友申请: ${count.friendRequestUnreadCount}');
        debugPrint('   活动申请: ${count.activityRequestUnreadCount}');
        
        unreadCount.value = total;
      });
      
      // 🔥 首次加载时立即更新未读数
      final currentCount = MessageStorageService.to.totalUnreadCount.value;
      final total = currentCount.chatUnreadCount + 
                   currentCount.friendRequestUnreadCount + 
                   currentCount.activityRequestUnreadCount;
      unreadCount.value = total;
      
      debugPrint('✅ 未读消息监听初始化完成，当前未读数: $total');
      
    } catch (e) {
      debugPrint('❌ 初始化未读消息监听失败: $e');
    }
  }
}
